﻿using System;
using System.Collections;
using System.Linq;
using System.Text;
using System.IO;
using System.Runtime.Serialization.Formatters.Binary;
using System.Runtime.Serialization;
using System.Xml;
using System.Xml.Serialization;

namespace CreatingObjects3d
{
    [Serializable()]
    class ContenedorProyecto
    {
        private ArrayList arrayObjetos; //array con los objetos del proyecto.        
        private String ficheroProyecto; //fichero donde se guarda el proyecto.

        public ContenedorProyecto()
        {
            arrayObjetos = new ArrayList();
        }

        /// <summary>
        /// Guarda los datos de los objetos del array en el fichero del proyecto.
        /// </summary>
        /// <returns></returns>
        private Boolean guardarProyecto()
        {
            try
            {
                BinaryFormatter formato = new BinaryFormatter();
                Stream stream = new FileStream(ficheroProyecto, FileMode.Create, FileAccess.Write, FileShare.None);
                formato.Serialize(stream, arrayObjetos);
                stream.Flush();
                stream.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }

        private Boolean cargarProyecto()
        {
            try
            {
                BinaryFormatter formatter = new BinaryFormatter();
                Stream stream = new FileStream(ficheroProyecto, FileMode.Open, FileAccess.Read, FileShare.Read);
                arrayObjetos = (ArrayList)formatter.Deserialize(stream);
                stream.Close();
                return true;
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Devuelve o introduce la ruta del fichero del proyecto.
        /// </summary>
        public String FicheroProyecto
        {
            get { return ficheroProyecto; }
            set { ficheroProyecto = value; }
        }

        /// <summary>
        /// Carga los datos de los objetos del array en el fichero del proyecto.
        /// </summary>
        /// <returns></returns>
        public Boolean getCargarProyecto()
        {
            return cargarProyecto();
        }

        /// <summary>
        /// Guarda los datos de los objetos del array en el fichero del proyecto.
        /// </summary>
        /// <returns></returns>
        public Boolean setGuardarProyecto()
        {
            return guardarProyecto();
        }

        /// <summary>
        /// Introduce un objeto en el array de objetos del proyecto.
        /// </summary>
        /// <returns></returns>
        public void setIntroducirObjetos(Object objeto)
        {
            arrayObjetos.Add(objeto);
        }

        /// <summary>
        /// Devuelve el array de objetos del proyecto.
        /// </summary>
        /// <returns></returns>
        public ArrayList getObtenerObjetos()
        {
            return arrayObjetos;
        }

        /// <summary>
        /// Devuelve el objeto indicado del array de objetos. Si no lo encuentra devuelve null.
        /// Tipos por numeración: 1-Caja, 2-Cilindro, 3-Cono, 4-Esfera, 5-FicheroExterno, 6-Niebla, 7-Cielo y Suelo, 8-Panorama.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="tipoObjeto"></param>
        /// <returns></returns>
        public Object getObjeto(String id, int tipoObjeto)
        {
            ArrayList array = (ArrayList)arrayObjetos;
            switch (tipoObjeto)
            {
                case 1:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCaja))
                        {
                            ObjetoCaja objeto2 = (ObjetoCaja)objeto;
                            // Mateo aqui el .ToUpper lo pusiste por algun motivo? porque eso hace que falle, lo voy a dejar poniendo en toupper tambien al nombreObjeto
                            // porque si no menuda tela, no funcionaba xD.
                            if (objeto2.NombreObjeto.ToUpper().Equals(id.ToUpper()))
                            {
                                return objeto;
                            }
                        }
                    }
                    break;
                case 2:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCilindro))
                        {
                            ObjetoCilindro objeto2 = (ObjetoCilindro)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(id.ToUpper()))
                            {
                                return objeto;
                            }
                        }
                    }
                    break;
                case 3:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCono))
                        {
                            ObjetoCono objeto2 = (ObjetoCono)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(id.ToUpper()))
                            {
                                return objeto;
                            }
                        }
                    }
                    break;
                case 4:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoEsfera))
                        {
                            ObjetoEsfera objeto2 = (ObjetoEsfera)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(id.ToUpper()))
                            {
                                return objeto;
                            }
                        }
                    }
                    break;
                case 5:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoFicheroExterno))
                        {
                            ObjetoFicheroExterno objeto2 = (ObjetoFicheroExterno)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(id.ToUpper()))
                            {
                                return objeto;
                            }
                        }
                    }
                    break;
                case 6:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoNiebla))
                        {
                            return objeto;
                        }
                    }
                    break;
                case 7:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCieloSuelo))
                        {
                            return objeto;
                        }
                    }
                    break;
                case 8:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoPanorama))
                        {
                            return objeto;
                        }
                    }
                    break;
            }
            return null;
        }

        /// <summary>
        /// Devuelve el número de objetos del mismo tipo y con el mismo nombre que hay en el array.        
        /// Tipos por numeración: 1-Caja, 2-Cilindro, 3-Cono, 4-Esfera, 5-FicheroExterno.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="tipoObjeto"></param>
        /// <returns></returns>
        public int getObjetosRepetidos(String id, int tipoObjeto)
        {
            ArrayList array = (ArrayList)arrayObjetos;
            int contador = 0;
            switch (tipoObjeto)
            {
                case 1:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCaja))
                        {
                            ObjetoCaja objeto2 = (ObjetoCaja)objeto;
                            if (objeto2.NombreObjeto.Equals(id.ToUpper()))
                            {
                                contador++;
                            }
                        }
                    }
                    break;
                case 2:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCilindro))
                        {
                            ObjetoCilindro objeto2 = (ObjetoCilindro)objeto;
                            if (objeto2.NombreObjeto.Equals(id.ToUpper()))
                            {
                                contador++;
                            }
                        }
                    }
                    break;
                case 3:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCono))
                        {
                            ObjetoCono objeto2 = (ObjetoCono)objeto;
                            if (objeto2.NombreObjeto.Equals(id.ToUpper()))
                            {
                                contador++;
                            }
                        }
                    }
                    break;
                case 4:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoEsfera))
                        {
                            ObjetoEsfera objeto2 = (ObjetoEsfera)objeto;
                            if (objeto2.NombreObjeto.Equals(id.ToUpper()))
                            {
                                contador++;
                            }
                        }
                    }
                    break;
                case 5:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoFicheroExterno))
                        {
                            ObjetoFicheroExterno objeto2 = (ObjetoFicheroExterno)objeto;
                            if (objeto2.NombreObjeto.Equals(id.ToUpper()))
                            {
                                contador++;
                            }
                        }
                    }
                    break;
            }
            return contador;
        }

        /// <summary>
        /// Devuelve un arrayList con los objetos que hay en el contenedor de proyecto del tipo indicado.
        /// Tipos por numeración: 1-Caja, 2-Cilindro, 3-Cono, 4-Esfera, 5-FicheroExterno, 6-Niebla, 7-Cielo y Suelo, 8-Panorama.
        /// </summary>
        /// <param name="id"></param>
        /// <param name="tipoObjeto"></param>
        /// <returns></returns>
        public ArrayList getObjeto(int tipoObjeto)
        {
            ArrayList devolverDatos = new ArrayList();
            switch (tipoObjeto)
            {
                case 1:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoCaja))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 2:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoCilindro))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 3:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoCono))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 4:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoEsfera))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 5:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoFicheroExterno))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 6:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoNiebla))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 7:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoCieloSuelo))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                case 8:
                    foreach (Object objeto in arrayObjetos)
                    {
                        if (objeto.GetType() == typeof(ObjetoPanorama))
                        {
                            devolverDatos.Add(objeto);
                        }
                    }
                    break;
                default:
                    return devolverDatos;
            }
            return devolverDatos;
        }

        /// <summary>
        /// Elimina un objeto del array de objetos
        /// Hay que indicar el tipo de objeto y su nombre
        /// Tipos por numeración: 1-Caja, 2-Cilindro, 3-Cono, 4-Esfera, 5-FicheroExterno, 6-Niebla, 7-Cielo y Suelo, 8-Panorama.
        /// En el caso de Niebla, cielo o panorama el nombre no se usa, se puede indicar cualquier cosa.
        /// </summary>
        /// <param name="nombre"></param>
        /// <param name="tipoObjeto"></param>
        /// <returns></returns>
        public Boolean setBorrarObjetoArray(String nombre, int tipoObjeto)
        {
            ArrayList array = (ArrayList)arrayObjetos;
            int posicion = 0;
            switch (tipoObjeto)
            {
                case 1:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCaja))
                        {
                            ObjetoCaja objeto2 = (ObjetoCaja)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(nombre.ToUpper()))
                            {
                                arrayObjetos.RemoveAt(posicion);
                                return true;
                            }
                        }
                        posicion++;
                    }
                    break;
                case 2:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCilindro))
                        {
                            ObjetoCilindro objeto2 = (ObjetoCilindro)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(nombre.ToUpper()))
                            {
                                arrayObjetos.RemoveAt(posicion);
                                return true;
                            }
                        }
                        posicion++;
                    }
                    break;
                case 3:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCono))
                        {
                            ObjetoCono objeto2 = (ObjetoCono)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(nombre.ToUpper()))
                            {
                                arrayObjetos.RemoveAt(posicion);
                                return true;
                            }
                        }
                        posicion++;
                    }
                    break;
                case 4:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoEsfera))
                        {
                            ObjetoEsfera objeto2 = (ObjetoEsfera)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(nombre.ToUpper()))
                            {
                                arrayObjetos.RemoveAt(posicion);
                                return true;
                            }
                        }
                        posicion++;
                    }
                    break;
                case 5:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoFicheroExterno))
                        {
                            ObjetoFicheroExterno objeto2 = (ObjetoFicheroExterno)objeto;
                            if (objeto2.NombreObjeto.ToUpper().Equals(nombre.ToUpper()))
                            {
                                arrayObjetos.RemoveAt(posicion);
                                return true;
                            }
                        }
                        posicion++;
                    }
                    break;
                case 6:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoNiebla))
                        {
                            arrayObjetos.RemoveAt(posicion);
                            return true;
                        }
                        posicion++;
                    }
                    break;
                case 7:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoCieloSuelo))
                        {
                            arrayObjetos.RemoveAt(posicion);
                            return true;
                        }
                        posicion++;
                    }
                    break;
                case 8:
                    foreach (Object objeto in array)
                    {
                        if (objeto.GetType() == typeof(ObjetoPanorama))
                        {
                            arrayObjetos.RemoveAt(posicion);
                            return true;
                        }
                        posicion++;
                    }
                    break;
            }
            return false;
        }

        /// <summary>
        /// Método que recibe una ruta de un fichero, ejemplo: "C:\ruta\fichero.wrl", y separa la parte correspondiente a la ruta (sin fichero)
        /// de la parte correspondiente a "fichero.extensión". Ambas partes son devueltas en un array de Strings de 2 posiciones.
        /// </summary>
        /// <param name="ruta"></param>
        /// <returns></returns>
        private String[] separarRutaFichero(String ruta)
        {
            String[] rutasyficheros = new String[2];
            int longitudCadena = ruta.Length;
            int posicion = 0;
            char[] arrayChar = ruta.ToCharArray();
            for (int i = longitudCadena - 1; i > 0 && arrayChar[i] != '\\'; i--)
            {
                posicion = i;
            }
            rutasyficheros[0] = ruta.Substring(0, posicion);
            rutasyficheros[1] = ruta.Substring(posicion);
            return rutasyficheros;
        }

        /// <summary>
        /// Metodo para copiar los ficheros de un directorio origen a un directorio destino
        /// </summary>
        /// <param name="rutaOrigen"></param>
        /// <param name="rutaDestino"></param>
        /// <param name="nombreFichero"></param>
        /// <returns></returns>
        private Boolean copiarFichero(String rutaOrigen, String rutaDestino, String nombreFichero)
        {
            try
            {
                string sourceFile = System.IO.Path.Combine(rutaOrigen, nombreFichero);
                string destFile = System.IO.Path.Combine(rutaDestino, nombreFichero);

                if (System.IO.File.Exists(rutaOrigen + nombreFichero))
                {
                    System.IO.File.Copy(sourceFile, destFile, true);
                    return true;
                }
                else
                {
                    return false;
                }
            }
            catch
            {
                return false;
            }
        }

        /// <summary>
        /// Método para copiar los archivos de imágenes de los distintos objetos al directorio del proyecto.
        /// </summary>
        private Boolean adjuntarImagenesProyecto()
        {
            Boolean copiaCorrecta = true;
            String rutaProyecto = separarRutaFichero(ficheroProyecto)[0];
            foreach (Object objeto in arrayObjetos)
            {
                if (objeto.GetType() == typeof(ObjetoCaja))
                {
                    ObjetoCaja caja = (ObjetoCaja)objeto;
                    if (caja.Imagen != "")
                    {
                        try
                        {
                            caja.RutaImgagenOriginal = caja.Imagen; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(caja.Imagen);
                            if (!rutaProyecto.Equals(imagen[0]))
                            {
                                if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                                {
                                    copiaCorrecta = false;
                                }
                            }
                            caja.Imagen = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                }
                else if (objeto.GetType() == typeof(ObjetoCilindro))
                {
                    ObjetoCilindro cilindro = (ObjetoCilindro)objeto;
                    if (cilindro.Imagen != "")
                    {
                        try
                        {
                            cilindro.RutaImgagenOriginal = cilindro.Imagen; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(cilindro.Imagen);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            cilindro.Imagen = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;                            
                        }
                    }
                }
                else if (objeto.GetType() == typeof(ObjetoCono))
                {
                    ObjetoCono cono = (ObjetoCono)objeto;
                    if (cono.Imagen != "")
                    {
                        try
                        {
                            cono.RutaImgagenOriginal = cono.Imagen; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(cono.Imagen);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            cono.Imagen = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                }
                else if (objeto.GetType() == typeof(ObjetoEsfera))
                {
                    ObjetoEsfera esfera = (ObjetoEsfera)objeto;
                    if (esfera.Imagen != "")
                    {
                        try
                        {
                            esfera.RutaImgagenOriginal = esfera.Imagen; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(esfera.Imagen);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            esfera.Imagen = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                }
                else if (objeto.GetType() == typeof(ObjetoPanorama))
                {
                    ObjetoPanorama panorama = (ObjetoPanorama)objeto;
                    if (panorama.ImagenAbajo != "")
                    {
                        try
                        {
                            panorama.ImagenAbajoProyecto = panorama.ImagenAbajo; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(panorama.ImagenAbajo);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            panorama.ImagenAbajo = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                    if (panorama.ImagenArriba != "")
                    {
                        try
                        {
                            panorama.ImagenArribaProyecto = panorama.ImagenArriba; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(panorama.ImagenArriba);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            panorama.ImagenArriba = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                    if (panorama.ImagenDerecha != "")
                    {
                        try
                        {
                            panorama.ImagenDerechaProyecto = panorama.ImagenDerecha; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(panorama.ImagenDerecha);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            panorama.ImagenDerecha = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                    if (panorama.ImagenIzquierda != "")
                    {
                        try
                        {
                            panorama.ImagenIzquierdaProyecto = panorama.ImagenIzquierda; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(panorama.ImagenIzquierda);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            panorama.ImagenIzquierda = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                    if (panorama.ImagenTrasera != "")
                    {
                        try
                        {
                            panorama.ImagenTraseraProyecto = panorama.ImagenTrasera; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(panorama.ImagenTrasera);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            panorama.ImagenTrasera = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                    if (panorama.ImagenFrontal != "")
                    {
                        try
                        {
                            panorama.ImagenFrontalProyecto = panorama.ImagenFrontal; //guardamos la ruta original de la imagen para mostrarla en el proyecto
                            String[] imagen = separarRutaFichero(panorama.ImagenFrontal);
                            if (!copiarFichero(imagen[0], rutaProyecto, imagen[1]))
                            {
                                copiaCorrecta = false;
                            }
                            panorama.ImagenFrontal = imagen[1];
                        }
                        catch
                        {
                            copiaCorrecta = false;
                        }
                    }
                }
            }
            if (copiaCorrecta)
            {
                return true;
            }
            else
            {
                return false;
            }
        }

        /// <summary>
        /// Método para devolver las rutas originales a las variables imagen de los objetos.
        /// </summary>
        private void restaurarRutasImagenes()
        {
            foreach (Object objeto in arrayObjetos)
            {
                if (objeto.GetType() == typeof(ObjetoCaja) || objeto.GetType() == typeof(ObjetoCono) || objeto.GetType() == typeof(ObjetoCilindro) ||
                    objeto.GetType() == typeof(ObjetoEsfera))
                {
                    Objeto objetoTipo = (Objeto)objeto;                    
                    objetoTipo.Imagen = objetoTipo.RutaImgagenOriginal;
                }
                else if (objeto.GetType() == typeof(ObjetoPanorama))
                {
                    ObjetoPanorama panorama = (ObjetoPanorama)objeto;
                    panorama.ImagenFrontal = panorama.ImagenFrontalProyecto;
                    panorama.ImagenTrasera = panorama.ImagenTraseraProyecto;
                    panorama.ImagenArriba = panorama.ImagenArribaProyecto;
                    panorama.ImagenAbajo = panorama.ImagenAbajoProyecto;
                    panorama.ImagenDerecha = panorama.ImagenDerechaProyecto;
                    panorama.ImagenIzquierda = panorama.ImagenIzquierdaProyecto;
                }                
            }            
        }

        /// <summary>
        /// Genera el fichero con extensión .wrl para poder ser ejecutado por FluxPlayer y visualizar el entorno virtual.
        /// </summary>
        /// <returns></returns>
        public Boolean getGenerarFicheroWRL()
        {
            Type cielo = typeof(ObjetoCieloSuelo);
            Type panorama = typeof(ObjetoPanorama);
            String fichero = ficheroProyecto.Substring(0, ficheroProyecto.Length - 4);
            String fondo;
            fichero += ".wrl";

            adjuntarImagenesProyecto(); //Se copian los archivos de imágenes a la ruta del proyecto

            try
            {
                System.IO.StreamWriter sw = new System.IO.StreamWriter(fichero, false);
                sw.WriteLine("#VRML V2.0 utf8");
                foreach (Object objeto in arrayObjetos)
                {
                    if (objeto.GetType() != cielo && objeto.GetType() != panorama)
                    {
                        sw.WriteLine(objeto.ToString());
                    }
                }
                fondo = "Background {";
                foreach (Object objeto in arrayObjetos)
                {
                    if (objeto.GetType() == cielo || objeto.GetType() == panorama)
                    {
                        fondo += objeto.ToString();
                    }
                }
                fondo += "}";
                sw.WriteLine(fondo);
                sw.Flush();
                sw.Close();
                restaurarRutasImagenes();
                return true;
            }
            catch
            {
                restaurarRutasImagenes();
                return false;
            }
        }

        public ArrayList getArrayObjetos()
        {
            return arrayObjetos;
        }
    }
}

/*
 * 
 * Leer del fichero linea a linea.
 int counter = 0;
string line;

// Read the file and display it line by line.
System.IO.StreamReader file = 
    new System.IO.StreamReader(@"c:\test.txt");
while((line = file.ReadLine()) != null)
{
    System.Console.WriteLine (line);
    counter++;
}

file.Close();
System.Console.WriteLine("There were {0} lines.", counter);
// Suspend the screen.
System.Console.ReadLine();
 
 * Escribir en un fichero
 System.IO.StreamWriter sw = new System.IO.StreamWriter(fic);
 sw.WriteLine(texto);
 sw.Close(); 
 */
